<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>4. Una introducción informal a Python &mdash; Tutorial de Python v2.6.2 documentation</title>
    <link rel="stylesheet" href="_static/default.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '#',
        VERSION:     '2.6.2',
        COLLAPSE_MODINDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="_static/jquery.js"></script>
    <script type="text/javascript" src="_static/doctools.js"></script>
    <link rel="top" title="Tutorial de Python v2.6.2 documentation" href="index.html" />
    <link rel="next" title="5. Más herramientas para control de flujo" href="controlflow.html" />
    <link rel="prev" title="3. Usando el intérprete de Python" href="interpreter.html" /> 
  </head>
  <body>
    <div class="related">
      <h3>Navegación</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="Índice General"
             accesskey="I">índice</a></li>
        <li class="right" >
          <a href="controlflow.html" title="5. Más herramientas para control de flujo"
             accesskey="N">siguiente</a> |</li>
        <li class="right" >
          <a href="interpreter.html" title="3. Usando el intérprete de Python"
             accesskey="P">anterior</a> |</li>
        <li><a href="contenido.html">Tutorial de Python v2.6.2 documentation</a> &raquo;</li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body">
            
  <div class="section" id="una-introduccion-informal-a-python">
<span id="tut-informal"></span><h1>4. Una introducción informal a Python<a class="headerlink" href="#una-introduccion-informal-a-python" title="Enlazar permanentemente con este título">¶</a></h1>
<p>En los siguientes ejemplos, las entradas y salidas son distinguidas por la
presencia o ausencia de los prompts (<tt class="docutils literal"><span class="pre">`&gt;&gt;&gt;`</span></tt> and <tt class="docutils literal"><span class="pre">`...`</span></tt>): para
reproducir los ejemplos, debés escribir todo lo que esté después del prompt,
cuando este aparezca; las líneas que no comiencen con el prompt son las
salidas del intérprete.  Tené en cuenta que el prompt secundario que
aparece por si sólo en una línea de un ejemplo significa que debés escribir
una línea en blanco; esto es usado para terminar un comando multilínea.</p>
<p>Muchos de los ejemplos de este manual, incluso aquellos ingresados en el prompt
interactivo, incluyen comentarios.  Los comentarios en Python comienzan con
el carácter numeral, <tt class="docutils literal"><span class="pre">#</span></tt>, y se extienden hasta el final físico de la
línea.  Un comentario quizás aparezca al comienzo de la línea o seguidos
de espacios blancos o código, pero sin una cadena de caracteres.  Un carácter
numeral dentro de una cadena de caracteres es sólo un carácter numeral.  Ya que
los comentarios son para aclarar código y no son interpretados por Python,
pueden omitirse cuando se escriben ejemplos.</p>
<p>Algunos ejemplos:</p>
<div class="highlight-python"><pre># este es el primer comentario
SPAM = 1                 # y este es el segundo comentario
                         # ... y ahora un tercero!
STRING = "# Este no es un comentario".</pre>
</div>
<div class="section" id="usar-python-como-una-calculadora">
<span id="tut-calculator"></span><h2>4.1. Usar Python como una calculadora<a class="headerlink" href="#usar-python-como-una-calculadora" title="Enlazar permanentemente con este título">¶</a></h2>
<p>Vamos a probar algunos comandos simples en Python.  Iniciá un intérprete y
esperá por el prompt primario, <tt class="docutils literal"><span class="pre">&gt;&gt;&gt;</span></tt>. (No debería demorar tanto).</p>
<div class="section" id="numeros">
<span id="tut-numbers"></span><h3>4.1.1. Números<a class="headerlink" href="#numeros" title="Enlazar permanentemente con este título">¶</a></h3>
<p>El intérprete actúa como una simple calculadora; podés ingrsar una expresión
y este escribirá los valores.  La sintaxis es sencilla: los operadores <tt class="docutils literal"><span class="pre">+</span></tt>,
<tt class="docutils literal"><span class="pre">-</span></tt>, <tt class="docutils literal"><span class="pre">*</span></tt> y <tt class="docutils literal"><span class="pre">/</span></tt> funcionan como en la mayoría de los lenguajes (por
ejemplo, Pascal o C); los paréntesis pueden ser usados para agrupar. Por
ejemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="mi">2</span><span class="o">+</span><span class="mi">2</span>
<span class="go">4</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c"># Este es un comentario</span>
<span class="gp">... </span><span class="mi">2</span><span class="o">+</span><span class="mi">2</span>
<span class="go">4</span>
<span class="gp">&gt;&gt;&gt; </span><span class="mi">2</span><span class="o">+</span><span class="mi">2</span>  <span class="c"># y un comentario en la misma línea que el código</span>
<span class="go">4</span>
<span class="gp">&gt;&gt;&gt; </span><span class="p">(</span><span class="mi">50</span><span class="o">-</span><span class="mi">5</span><span class="o">*</span><span class="mi">6</span><span class="p">)</span><span class="o">/</span><span class="mi">4</span>
<span class="go">5</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c"># La división entera retorna redondeado al piso:</span>
<span class="gp">... </span><span class="mi">7</span><span class="o">/</span><span class="mi">3</span>
<span class="go">2</span>
<span class="gp">&gt;&gt;&gt; </span><span class="mi">7</span><span class="o">/-</span><span class="mi">3</span>
<span class="go">-3</span>
</pre></div>
</div>
<p>El signo igual (<tt class="docutils literal"><span class="pre">=</span></tt>) es usado para asignar un valor a una variable.  Luego,
ningún resultado es mostrado antes del próximo prompt:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">ancho</span> <span class="o">=</span> <span class="mi">20</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">largo</span> <span class="o">=</span> <span class="mi">5</span><span class="o">*</span><span class="mi">9</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">ancho</span> <span class="o">*</span> <span class="n">largo</span>
<span class="go">900</span>
</pre></div>
</div>
<p>Un valor puede ser asignado a varias variables simultáneamente:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">y</span> <span class="o">=</span> <span class="n">z</span> <span class="o">=</span> <span class="mi">0</span>  <span class="c"># Cero a x, y, y z</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">0</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span>
<span class="go">0</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">z</span>
<span class="go">0</span>
</pre></div>
</div>
<p>Las variables deben estar &#8220;definidas&#8221; (con un valor asignado) antes de que
puedan usarse, o un error ocurrirá:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="c"># tratamos de acceder a una variable no definida</span>
<span class="gp">... </span><span class="n">n</span>
<span class="gt">Traceback (most recent call last):</span>
  File <span class="nb">&quot;&lt;stdin&gt;&quot;</span>, line <span class="m">1</span>, in <span class="n-Identifier">&lt;module&gt;</span>
<span class="nc">NameError</span>: <span class="n-Identifier">name &#39;n&#39; is not defined</span>
</pre></div>
</div>
<p>Se soporta completamente los números de punto flotante; las operaciones con
mezclas en los tipos de los operandos convierten los enteros a punto flotante:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="mi">3</span> <span class="o">*</span> <span class="mf">3.75</span> <span class="o">/</span> <span class="mf">1.5</span>
<span class="go">7.5</span>
<span class="gp">&gt;&gt;&gt; </span><span class="mf">7.0</span> <span class="o">/</span> <span class="mi">2</span>
<span class="go">3.5</span>
</pre></div>
</div>
<p>Los números complejos también están soportados; los números imaginarios son
escritos con el sufijo de <tt class="docutils literal"><span class="pre">j</span></tt> o <tt class="docutils literal"><span class="pre">J</span></tt>.  Los números complejos con un
componente real que no sea cero son escritos como <tt class="docutils literal"><span class="pre">(real+imagj)</span></tt>, o pueden
ser escrito con la función <tt class="docutils literal"><span class="pre">complex(real,</span> <span class="pre">imag)</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="mi">1</span><span class="n">j</span> <span class="o">*</span> <span class="mi">1</span><span class="n">J</span>
<span class="go">(-1+0j)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="mi">1</span><span class="n">j</span> <span class="o">*</span> <span class="nb">complex</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span>
<span class="go">(-1+0j)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="mi">3</span><span class="o">+</span><span class="mi">1</span><span class="n">j</span><span class="o">*</span><span class="mi">3</span>
<span class="go">(3+3j)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="p">(</span><span class="mi">3</span><span class="o">+</span><span class="mi">1</span><span class="n">j</span><span class="p">)</span><span class="o">*</span><span class="mi">3</span>
<span class="go">(9+3j)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="p">(</span><span class="mi">1</span><span class="o">+</span><span class="mi">2</span><span class="n">j</span><span class="p">)</span><span class="o">/</span><span class="p">(</span><span class="mi">1</span><span class="o">+</span><span class="mi">1</span><span class="n">j</span><span class="p">)</span>
<span class="go">(1.5+0.5j)</span>
</pre></div>
</div>
<p>Los números complejos son siempre representados como dos números de punto
flotante, la parte real y la imaginaria.  Para extraer estas partes desde un
número complejo <em>z</em>, usá <tt class="docutils literal"><span class="pre">z.real</span></tt> y <tt class="docutils literal"><span class="pre">z.imag</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">=</span><span class="mf">1.5</span><span class="o">+</span><span class="mf">0.5</span><span class="n">j</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">real</span>
<span class="go">1.5</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">imag</span>
<span class="go">0.5</span>
</pre></div>
</div>
<p>La función de conversión de los punto flotante y enteros (<tt class="xref docutils literal"><span class="pre">float()</span></tt>,
<tt class="xref docutils literal"><span class="pre">int()</span></tt> y <tt class="xref docutils literal"><span class="pre">long()</span></tt>) no funciona para números complejos; aquí no hay
una forma correcta de convertir un número complejo a un número real.  Usá
<tt class="docutils literal"><span class="pre">abs(z)</span></tt> para obtener esta magnitud (como un flotante) o <tt class="docutils literal"><span class="pre">z.real</span></tt> para
obtener la parte real.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">=</span><span class="mf">3.0</span><span class="o">+</span><span class="mf">4.0</span><span class="n">j</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">float</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="nc">TypeError</span>: <span class="n-Identifier">can&#39;t convert complex to float</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">real</span>
<span class="go">3.0</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">imag</span>
<span class="go">4.0</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">abs</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>  <span class="c"># sqrt(a.real**2 + a.imag**2)</span>
<span class="go">5.0</span>
<span class="go">&gt;&gt;&gt;</span>
</pre></div>
</div>
<p>En el modo interactivo, la última expresión impresa es asignada a la variable
<tt class="docutils literal"><span class="pre">_</span></tt>.  Esto significa que cuando estés usando Python como una calculadora de
escritorio, es más fácil seguir calculando, por ejemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">impuesto</span> <span class="o">=</span> <span class="mf">12.5</span> <span class="o">/</span> <span class="mi">100</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">precio</span> <span class="o">=</span> <span class="mf">100.50</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">precio</span> <span class="o">*</span> <span class="n">impuesto</span>
<span class="go">12.5625</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">precio</span> <span class="o">+</span> <span class="n">_</span>
<span class="go">113.0625</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">round</span><span class="p">(</span><span class="n">_</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">113.06</span>
<span class="go">&gt;&gt;&gt;</span>
</pre></div>
</div>
<p>Esta variable debería ser tratada como de sólo lectura por el usuario.  No le
asignes explícitamente un valor; crearás una variable local independiente con
el mismo nombre enmascarando la variable con el comportamiento mágico.</p>
</div>
<div class="section" id="cadenas-de-caracteres">
<span id="tut-strings"></span><h3>4.1.2. Cadenas de caracteres<a class="headerlink" href="#cadenas-de-caracteres" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Además de números, Python puede manipular cadenas de texto, las cuales pueden
ser expresadas de distintas formas.  Pueden estar encerradas en comillas
simples o dobles:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;huevos y pan&#39;</span>
<span class="go">&#39;huevos y pan&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;doesn</span><span class="se">\&#39;</span><span class="s">t&#39;</span>
<span class="go">&quot;doesn&#39;t&quot;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&quot;doesn&#39;t&quot;</span>
<span class="go">&quot;doesn&#39;t&quot;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;&quot;Si,&quot; le dijo.&#39;</span>
<span class="go">&#39;&quot;Si,&quot; le dijo.&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&quot;</span><span class="se">\&quot;</span><span class="s">Si,</span><span class="se">\&quot;</span><span class="s"> le dijo.&quot;</span>
<span class="go">&#39;&quot;Si,&quot; le dijo.&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;&quot;Isn</span><span class="se">\&#39;</span><span class="s">t,&quot; she said.&#39;</span>
<span class="go">&#39;&quot;Isn\&#39;t,&quot; she said.&#39;</span>
</pre></div>
</div>
<p>Las cadenas de texto literales pueden contener múltiples líneas de distintas
formas.  Las líneas continuas se pueden usar, con una barra invertida como el
último carácter de la línea para indicar que la siguiente línea es la
continuación lógica de la línea:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">hola</span> <span class="o">=</span> <span class="s">&quot;Esta es una larga cadena que contiene</span><span class="se">\n\</span>
<span class="s">varias líneas de texto, tal y como se hace en C.</span><span class="se">\n\</span>
<span class="s">    Notar que los espacios en blanco al principio de la linea</span><span class="se">\</span>
<span class="s"> son significantes.&quot;</span>

<span class="k">print</span> <span class="n">hola</span>
</pre></div>
</div>
<p>Notá que de todas formas se necesita embeber los salto de líneas con <tt class="docutils literal"><span class="pre">\n</span></tt>;
la nueva línea que sigue a la barra invertida final es descartada.  Este
ejemplo imprimiría:</p>
<div class="highlight-python"><pre>Esta es una larga cadena que contiene
varias líneas de texto, tal y como se hace en C.
     Notar que los espacios en blanco al principio de la linea son
     significantes.</pre>
</div>
<p>O, las cadenas de texto pueden ser rodeadas en un par de comillas triples:
<tt class="docutils literal"><span class="pre">&quot;&quot;&quot;</span></tt> o <tt class="docutils literal"><span class="pre">'''</span></tt>.  No se necesita escapar los finales de línea cuando se
utilizan comillas triples, pero serán incluidos en la cadena.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">print</span> <span class="s">&quot;&quot;&quot;</span>
<span class="s">Uso: algo [OPTIONS]</span>
<span class="s">     -h                        Muestra el mensaje de uso</span>
<span class="s">     -H nombrehost             Nombre del host al cual conectarse</span>
<span class="s">&quot;&quot;&quot;</span>
</pre></div>
</div>
<p>...produce la siguiente salida:</p>
<div class="highlight-python"><pre>Uso: algo [OPTIONS]
     -h                        Muestra el mensaje de uso
     -H nombrehost             Nombre del host al cual conectarse</pre>
</div>
<p>Si se hace de la cadena de texto una cadena &#8220;cruda&#8221;, la secuencia <tt class="docutils literal"><span class="pre">\n</span></tt> no
es convertida a salto de línea, pero la barra invertida al final de la línea
y el carácter de nueva línea en la fuente, ambos son incluidos en la cadena
como datos. Así, el ejemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">hola</span> <span class="o">=</span> <span class="s">r&quot;Esta es una larga cadena que contiene\n</span><span class="se">\</span>
<span class="s">varias líneas de texto, tal y como se hace en C.&quot;</span>

<span class="k">print</span> <span class="n">hola</span>
</pre></div>
</div>
<p>...imprimirá:</p>
<div class="highlight-python"><pre>Esta es una larga cadena que contiene\n\
varias líneas de texto, tal y como se hace en C.</pre>
</div>
<p>El interprete imprime el resultado de operaciones entre cadenas de la misma
forma en que son tecleadas como entrada: dentro de comillas, y con comillas y
otros caracteres raros escapados con barras invertidas, para mostrar
el valor preciso.  La cadena de texto es encerrada con comillas dobles si
contiene una comilla simple y no comillas dobles, sino es encerrada con
comillas simples.  (La declaración <tt class="xref docutils literal"><span class="pre">print</span></tt>, descrita luego,
puede ser usado para escribir cadenas sin comillas o escapes).</p>
<p>Las cadenas de texto pueden ser concatenadas (pegadas juntas) con el operador
<tt class="docutils literal"><span class="pre">+</span></tt> y repetidas con <tt class="docutils literal"><span class="pre">*</span></tt>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span> <span class="o">=</span> <span class="s">&#39;Ayuda&#39;</span> <span class="o">+</span> <span class="s">&#39;A&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span>
<span class="go">&#39;AyudaA&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;&lt;&#39;</span> <span class="o">+</span> <span class="n">palabra</span><span class="o">*</span><span class="mi">5</span> <span class="o">+</span> <span class="s">&#39;&gt;&#39;</span>
<span class="go">&#39;&lt;AyudaAAyudaAAyudaAAyudaAAyudaA&gt;&#39;</span>
</pre></div>
</div>
<p>Dos cadenas de texto juntas son automáticamente concatenadas; la primer línea
del ejemplo anterior podría haber sido escrita <tt class="docutils literal"><span class="pre">palabra</span> <span class="pre">=</span> <span class="pre">'Ayuda'</span> <span class="pre">'A'</span></tt>; esto
solo funciona con dos literales, no con expresiones arbitrarias:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;cad&#39;</span> <span class="s">&#39;ena&#39;</span>                   <span class="c">#  &lt;-  Esto es correcto</span>
<span class="go">&#39;cadena&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;cad&#39;</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span> <span class="o">+</span> <span class="s">&#39;ena&#39;</span>   <span class="c">#  &lt;-  Esto es correcto</span>
<span class="go">&#39;cadena&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;cad&#39;</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span> <span class="s">&#39;ena&#39;</span>     <span class="c">#  &lt;-  Esto no es correcto</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="nc">SyntaxError</span>: <span class="n-Identifier">invalid syntax</span>
</pre></div>
</div>
<p>Las cadenas de texto se pueden indexar; como en C, el primer carácter de la
cadena tiene el índice 0.  No hay un tipo de dato para los caracteres; un
carácter es simplemente una cadena de longitud uno.  Como en Icon, se pueden
especificar subcadenas con la <em>notación de rebanadas</em>: dos índices separados
por dos puntos.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span>
<span class="go">&#39;a&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">2</span><span class="p">]</span>
<span class="go">&#39;Ay&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="mi">2</span><span class="p">:</span><span class="mi">4</span><span class="p">]</span>
<span class="go">&#39;ud&#39;</span>
</pre></div>
</div>
<p>Los índices de las rebanadas tienen valores por defecto útiles; el valor por
defecto para el primer índice es cero, el valor por defecto para el segundo
índice es la longitud de la cadena a rebanar.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span>    <span class="c"># Los primeros dos caracteres</span>
<span class="go">&#39;Ay&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="mi">2</span><span class="p">:]</span>    <span class="c"># Todo menos los primeros dos caracteres</span>
<span class="go">&#39;udaA&#39;</span>
</pre></div>
</div>
<p>A diferencia de las cadenas de texto en C, en Python no pueden ser
modificadas.  Intentar asignar a una posición de la cadena es un error:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s">&#39;x&#39;</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="nc">TypeError</span>: <span class="n-Identifier">&#39;str&#39; object does not support item assignment</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[:</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="s">&#39;Mas&#39;</span>
<span class="gt">Traceback (most recent call last):</span>
  File <span class="nb">&quot;&lt;stdin&gt;&quot;</span>, line <span class="m">1</span>, in <span class="n-Identifier">?</span>
<span class="nc">TypeError</span>: <span class="n-Identifier">&#39;str&#39; object does not support item assignment</span>
</pre></div>
</div>
<p>Sin embargo, crear una nueva cadena con contenido combinado es fácil y
eficiente:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;x&#39;</span> <span class="o">+</span> <span class="n">palabra</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="go">&#39;xyudaA&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;Mas&#39;</span> <span class="o">+</span> <span class="n">palabra</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span>
<span class="go">&#39;MasA&#39;</span>
</pre></div>
</div>
<p>Algo útil de las operaciones de rebanada: <tt class="docutils literal"><span class="pre">s[:i]</span> <span class="pre">+</span> <span class="pre">s[i:]</span></tt> es <tt class="docutils literal"><span class="pre">s</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span> <span class="o">+</span> <span class="n">palabra</span><span class="p">[</span><span class="mi">2</span><span class="p">:]</span>
<span class="go">&#39;AyudaA&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[:</span><span class="mi">3</span><span class="p">]</span> <span class="o">+</span> <span class="n">palabra</span><span class="p">[</span><span class="mi">3</span><span class="p">:]</span>
<span class="go">&#39;AyudaA&#39;</span>
</pre></div>
</div>
<p>Los índices degenerados en las rebanadas son manejados bien: un índice
muy largo es reemplazado por la longitud de la cadena, un límite superior más
chico que el límite menor retorna una cadena vacía.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="mi">100</span><span class="p">]</span>
<span class="go">&#39;yudaA&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="mi">10</span><span class="p">:]</span>
<span class="go">&#39;&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="mi">2</span><span class="p">:</span><span class="mi">1</span><span class="p">]</span>
<span class="go">&#39;&#39;</span>
</pre></div>
</div>
<p>Los índices pueden ser números negativos, para empezar a contar desde la
derecha. Por ejemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>     <span class="c"># El último caracter</span>
<span class="go">&#39;A&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">]</span>     <span class="c"># El penúltimo caracter</span>
<span class="go">&#39;a&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">:]</span>    <span class="c"># Los últimos dos caracteres</span>
<span class="go">&#39;aA&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[:</span><span class="o">-</span><span class="mi">2</span><span class="p">]</span>    <span class="c"># Todo menos los últimos dos caracteres</span>
<span class="go">&#39;Ayud&#39;</span>
</pre></div>
</div>
<p>Pero notá que -0 es en realidad lo mismo que 0, ¡por lo que no cuenta desde
la derecha!</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="o">-</span><span class="mi">0</span><span class="p">]</span>     <span class="c"># (ya que -0 es igual a 0)</span>
<span class="go">&#39;A&#39;</span>
</pre></div>
</div>
<p>Los índices negativos fuera de rango son truncados, pero esto no funciona para
índices de un solo elemento (no rebanada):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="o">-</span><span class="mi">100</span><span class="p">:]</span>
<span class="go">&#39;AyudaA&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">palabra</span><span class="p">[</span><span class="o">-</span><span class="mi">10</span><span class="p">]</span>    <span class="c"># error</span>
<span class="gt">Traceback (most recent call last):</span>
  File <span class="nb">&quot;&lt;stdin&gt;&quot;</span>, line <span class="m">1</span>, in <span class="n-Identifier">?</span>
<span class="nc">IndexError</span>: <span class="n-Identifier">string index out of range</span>
</pre></div>
</div>
<p>Una forma de recordar cómo funcionan las rebanadas es pensar en los índices
como puntos <em>entre</em> caracteres, con el punto a la izquierda del primer carácter
numerado en 0.  Luego, el punto a la derecha del último carácter de una cadena
de <em>n</em> caracteres tienen índice <em>n</em>, por ejemplo:</p>
<div class="highlight-python"><pre> +---+---+---+---+---+---+
 | A | y | u | d | a | A |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1</pre>
</div>
<p>La primer fila de números da la posición de los índices 0...6 en la cadena;
la segunda fila da los correspondientes índices negativos. La rebanada de <em>i</em>
a <em>j</em> consiste en todos los caracteres entre los puntos etiquetados <em>i</em> y <em>j</em>,
respectivamente.</p>
<p>Para índices no negativos, la longitud de la rebanada es la diferencia de los
índices, si ambos entran en los límites. Por ejemplo, la longitud de
<tt class="docutils literal"><span class="pre">palabra[1:3]</span></tt> es 2.</p>
<p>La función incorporada <tt class="xref docutils literal"><span class="pre">len()</span></tt> devuelve la longitud de una cadena
de texto:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">s</span> <span class="o">=</span> <span class="s">&#39;supercalifrastilisticoespialidoso&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="go">33</span>
</pre></div>
</div>
<div class="admonition-ver-tambien admonition seealso">
<p class="first admonition-title">Ver también</p>
<dl class="last docutils">
<dt><em class="xref">typesseq</em></dt>
<dd>Las cadenas de texto y la cadenas de texto Unicode descritas en la
siguiente sección son ejemplos de <em>tipos secuencias</em>, y soportan
las operaciones comunes para esos tipos.</dd>
<dt><em class="xref">string-methods</em></dt>
<dd>Tanto las cadenas de texto normales como las cadenas de texto Unicode
soportan una gran cantidad de métodos para transformaciones básicas y
búsqueda.</dd>
<dt><em class="xref">new-string-formatting</em></dt>
<dd>Aquí se da información sobre formateo de cadenas de texto con
<tt class="xref docutils literal"><span class="pre">str.format()</span></tt>.</dd>
<dt><em class="xref">string-formatting</em></dt>
<dd>Aquí se describe con más detalle las operaciones viejas para formateo
usadas cuando una cadena de texto o una cadena Unicode están a la
izquierda del operador <tt class="docutils literal"><span class="pre">%</span></tt>.</dd>
</dl>
</div>
</div>
<div class="section" id="cadenas-de-texto-unicode">
<span id="tut-unicodestrings"></span><h3>4.1.3. Cadenas de texto Unicode<a class="headerlink" href="#cadenas-de-texto-unicode" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Desde la versión 2.0 de Python, se encuentra disponible un nuevo tipo de datos
para que los programadores almacenen texto: el objeto Unicode. Puede ser usado
para almacenar y manipular datos Unicode (ver <a class="reference external" href="http://www.unicode.org/">http://www.unicode.org/</a>) y se
integran bien con los objetos existentes para cadenas de texto, mediante
auto-conversión cuando es necesario.</p>
<p>Unicode tiene la ventaja de tener un número ordinal para cada carácter
usado tanto en textos modernos como antiguos.  Previamente, había sólo
256 ordinales posibles para los caracteres en scripts.  Los textos
eran típicamente asociados a un código que relaciona los ordinales a caracteres
en scripts.  Esto lleva a mucha confusión, especialmente al internacionalizar
software.  Unicode resuelve estos problemas definiendo una sola codificación
para todos los scripts.</p>
<p>Crear cadenas Unicode en Python es tan simple como crear cadenas de texto
normales:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="s">u&#39;Hola Mundo!&#39;</span>
<span class="go">u&#39;Hola Mundo!&#39;</span>
</pre></div>
</div>
<p>La <tt class="docutils literal"><span class="pre">'u'</span></tt> al frente de la comilla indica que se espera una cadena Unicode. Si
querés incluir caracteres especiales en la cadena, podés hacerlo usando una
forma de escapar caracteres Unicode provista por Python.  El siguiente ejemplo
muestra cómo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="s">u&#39;Hola</span><span class="se">\u0020</span><span class="s">Mundo!&#39;</span>
<span class="go">u&#39;Hola Mundo!&#39;</span>
</pre></div>
</div>
<p>La secuencia de escape <tt class="docutils literal"><span class="pre">\u0020</span></tt> indica que se debe insertar el carácter
Unicode con valor ordinal 0x0020 (el espacio en blanco) en la posición dada.</p>
<p>Otros caracteres son interpretados usando su respectivo valor ordinal como
ordinales Unicode. Si tenés cadenas de texto literales en la codificación
estándar Latin-1 que es muy usada en países occidentales, encontrarás
conveniente que los primeros 256 caracteres de Unicode son los mismos primeros
256 caracteres de Latin-1.</p>
<p>También existe un modo crudo para expertos, del mismo modo que con las cadenas
de texto normales. Debés anteponer &#8216;ur&#8217; a la comilla inicial para que Python
use el modo de escape crudo de Unicode. Solo se aplicará la conversión
<tt class="docutils literal"><span class="pre">\uXXXX</span></tt> si hay un número impar de barras invertidas frente a la &#8216;u&#8217;.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="s">ur&#39;Hola\u0020Mundo!&#39;</span>
<span class="go">u&#39;Hola Mundo!&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">ur&#39;Hola</span><span class="se">\\</span><span class="s">u0020Mundo!&#39;</span>
<span class="go">u&#39;Hola\\\\u0020Mundo!&#39;</span>
</pre></div>
</div>
<p>El modo crudo es útil principalmente cuando tenés que insertar muchas
barras invertidas, como puede suceder al trabajar con expresiones regulares.</p>
<p>Además de estas codificaciones estándar, Python provee muchas más formas de
crear cadenas de texto Unicode en las bases de codificaciones conocidas.</p>
<p id="index-71">La función predefinida <tt class="xref docutils literal"><span class="pre">unicode()</span></tt> da acceso a todos los codecs
(CODificadores y DECodificadores).  Algunos de los códigos más conocidos
que estos codecs pueden convertir son <em>Latin-1</em>, <em>ASCII</em>, <em>UTF-8</em>, y <em>UTF-16</em>.
Los dos últimas son códigos de longitud variable que almacenan cada
carácter Unicode en uno o más bytes.  El código por defecto es normalmente
configurado a ASCII, que contiene los caracteres del rango 0-127 y rechaza
cualquier otro con un error.  Cuando una cadena Unicode se imprime, escribe en
un archivo, o se convierte con la función <tt class="xref docutils literal"><span class="pre">str()</span></tt>, se realiza la conversión
utilizando el código por defecto.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="s">u&quot;abc&quot;</span>
<span class="go">u&#39;abc&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">str</span><span class="p">(</span><span class="s">u&quot;abc&quot;</span><span class="p">)</span>
<span class="go">&#39;abc&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">u&quot;äöü&quot;</span>
<span class="go">u&#39;\xe4\xf6\xfc&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">str</span><span class="p">(</span><span class="s">u&quot;äöü&quot;</span><span class="p">)</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="nc">UnicodeEncodeError: &#39;ascii&#39; codec can&#39;t encode characters in position 0-5</span>: <span class="n-Identifier">ordinal not in range(128)</span>
</pre></div>
</div>
<p>Para convertir una cadena Unicode en una cadena de 8-bit utilizando un
código en particular, los objetos Unicode tienen un método <tt class="xref docutils literal"><span class="pre">encode()</span></tt>
que toma un argumento, el nombre del código. Se prefieren los nombres
en minúsculas para los nombres de los códigos.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="s">u&quot;äöü&quot;</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s">&#39;utf-8&#39;</span><span class="p">)</span>
<span class="go">&#39;\xc3\xa4\xc3\xb6\xc3\xbc&#39;</span>
</pre></div>
</div>
<p>Si tenés datos en un código en particular y querés producir la cadena
Unicode correspondiente, podés usar la función <tt class="xref docutils literal"><span class="pre">unicode()</span></tt> con el nombre
del código como segundo argumento.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="nb">unicode</span><span class="p">(</span><span class="s">&#39;</span><span class="se">\xc3\xa4\xc3\xb6\xc3\xbc</span><span class="s">&#39;</span><span class="p">,</span> <span class="s">&#39;utf-8&#39;</span><span class="p">)</span>
<span class="go">u&#39;\xe4\xf6\xfc&#39;</span>
</pre></div>
</div>
</div>
<div class="section" id="listas">
<span id="tut-lists"></span><h3>4.1.4. Listas<a class="headerlink" href="#listas" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Python tiene varios tipos de datos <em>compuestos</em>, usados para agrupar otros
valores.  El más versátil es la <em>lista</em>, la cual puede ser escrita como una
lista de valores separados por coma (ítems) entre corchetes.  No es necesario
que los ítems de una lista tengan todos el mismo tipo.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="p">[</span><span class="s">&#39;pan&#39;</span><span class="p">,</span> <span class="s">&#39;huevos&#39;</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">1234</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[&#39;pan&#39;, &#39;huevos&#39;, 100, 1234]</span>
</pre></div>
</div>
<p>Como los índices de las cadenas de texto, los índices de las listas comienzan
en 0, y las listas pueden ser rebanadas, concatenadas y todo lo demás:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="go">&#39;pan&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span>
<span class="go">1234</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">]</span>
<span class="go">100</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="go">[&#39;huevos&#39;, 100]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span> <span class="o">+</span> <span class="p">[</span><span class="s">&#39;carne&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="o">*</span><span class="mi">2</span><span class="p">]</span>
<span class="go">[&#39;pan&#39;, &#39;huevos&#39;, &#39;carne&#39;, 4]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="mi">3</span><span class="o">*</span><span class="n">a</span><span class="p">[:</span><span class="mi">3</span><span class="p">]</span> <span class="o">+</span> <span class="p">[</span><span class="s">&#39;Boo!&#39;</span><span class="p">]</span>
<span class="go">[&#39;pan&#39;, &#39;huevos&#39;, 100, &#39;pan&#39;, &#39;huevos&#39;, 100, &#39;pan&#39;, &#39;huevos&#39;, 100, &#39;Boo!&#39;]</span>
</pre></div>
</div>
<p>A diferencia de las cadenas de texto, que son <em>inmutables</em>, es posible cambiar
un elemento individual de una lista:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[&#39;pan&#39;, &#39;huevos&#39;, 100, 1234]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">=</span> <span class="n">a</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">+</span> <span class="mi">23</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[&#39;pan&#39;, &#39;huevos&#39;, 123, 1234]</span>
</pre></div>
</div>
<p>También es posible asignar a una rebanada, y esto incluso puede cambiar la
longitud de la lista o vaciarla totalmente:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="c"># Reemplazar algunos elementos:</span>
<span class="gp">... </span><span class="n">a</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">2</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">12</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[1, 12, 123, 1234]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c"># Borrar algunos:</span>
<span class="gp">... </span><span class="n">a</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">2</span><span class="p">]</span> <span class="o">=</span> <span class="p">[]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[123, 1234]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c"># Insertar algunos:</span>
<span class="gp">... </span><span class="n">a</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="s">&#39;bruja&#39;</span><span class="p">,</span> <span class="s">&#39;xyzzy&#39;</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[123, &#39;bruja&#39;, &#39;xyzzy&#39;, 1234]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c"># Insertar (una copia de) la misma lista al principio</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[:</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="n">a</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[123, &#39;bruja&#39;, &#39;xyzzy&#39;, 1234, 123, &#39;bruja&#39;, &#39;xyzzy&#39;, 1234]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c"># Vaciar la lista: reemplazar todos los items con una lista vacía</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[:]</span> <span class="o">=</span> <span class="p">[]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[]</span>
</pre></div>
</div>
<p>La función predefinida <tt class="xref docutils literal"><span class="pre">len()</span></tt> también sirve para las listas:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="p">[</span><span class="s">&#39;a&#39;</span><span class="p">,</span> <span class="s">&#39;b&#39;</span><span class="p">,</span> <span class="s">&#39;c&#39;</span><span class="p">,</span> <span class="s">&#39;d&#39;</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">len</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">4</span>
</pre></div>
</div>
<p>Es posible anidar listas (crear listas que contengan otras listas), por
ejemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">q</span> <span class="o">=</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">p</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="n">q</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">len</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="go">3</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">p</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="go">[2, 3]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">p</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>
<span class="go">2</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">p</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s">&#39;extra&#39;</span><span class="p">)</span>     <span class="c"># Ver seccion 5.1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">p</span>
<span class="go">[1, [2, 3, &#39;extra&#39;], 4]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">q</span>
<span class="go">[2, 3, &#39;extra&#39;]</span>
</pre></div>
</div>
<p>Notá que en el último ejemplo, <tt class="docutils literal"><span class="pre">p[1]</span></tt> y <tt class="docutils literal"><span class="pre">q</span></tt> ¡realmente hacen referencia
al mismo objeto!  Volveremos a la <em>semántica de los objetos</em> más adelante.</p>
</div>
</div>
<div class="section" id="primeros-pasos-hacia-la-programacion">
<span id="tut-firststeps"></span><h2>4.2. Primeros pasos hacia la programación<a class="headerlink" href="#primeros-pasos-hacia-la-programacion" title="Enlazar permanentemente con este título">¶</a></h2>
<p>Por supuesto, podemos usar Python para tareas más complicadas que sumar dos
y dos.  Por ejemplo, podemos escribir una subsecuencia inicial de la serie de
<em>Fibonacci</em> así:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="c"># Series de Fibonacci:</span>
<span class="gp">... </span><span class="c"># la suma de dos elementos define el siguiente</span>
<span class="gp">... </span><span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">while</span> <span class="n">b</span> <span class="o">&lt;</span> <span class="mi">10</span><span class="p">:</span>
<span class="gp">... </span>    <span class="k">print</span> <span class="n">b</span>
<span class="gp">... </span>    <span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="n">b</span><span class="p">,</span> <span class="n">a</span><span class="o">+</span><span class="n">b</span>
<span class="gp">...</span>
<span class="go">1</span>
<span class="go">1</span>
<span class="go">2</span>
<span class="go">3</span>
<span class="go">5</span>
<span class="go">8</span>
</pre></div>
</div>
<p>Este ejemplo introduce varias características nuevas.</p>
<ul>
<li><p class="first">La primer línea contiene una <em>asignación múltiple</em>: las variables``a`` y
<tt class="docutils literal"><span class="pre">b</span></tt> toman en forma simultanea los nuevos valores 0 y 1.  En la última linea
esto es vuelto a usar, demostrando que las expresiones a la derecha son
evaluadas antes de que suceda cualquier asignación.  Las expresiones a la
derecha son evaluadas de izquierda a derecha.</p>
</li>
<li><p class="first">El bucle <tt class="xref docutils literal"><span class="pre">while</span></tt> se ejecuta mientras la condición (aquí: <tt class="docutils literal"><span class="pre">b</span> <span class="pre">&lt;</span> <span class="pre">10</span></tt>)
sea verdadera.  En Python, como en C, cualquier entero distinto de cero es
verdadero; cero es falso.  La condición también puede ser una cadena de texto
o una lista, de hecho cualquier secuencia; cualquier cosa con longitud
distinta de cero es verdadero, las secuencias vacías son falsas.  La prueba
usada en el ejemplo es una comparación simple.  Los operadores estándar de
comparación se escriben igual que en C: <tt class="docutils literal"><span class="pre">&lt;</span></tt> (menor qué), <tt class="docutils literal"><span class="pre">&gt;</span></tt> (mayor qué),
<tt class="docutils literal"><span class="pre">==</span></tt> (igual a), <tt class="docutils literal"><span class="pre">&lt;=</span></tt> (menor o igual qué), <tt class="docutils literal"><span class="pre">&gt;=</span></tt> (mayor o igual qué) y
<tt class="docutils literal"><span class="pre">!=</span></tt> (distinto a).</p>
</li>
<li><p class="first">El <em>cuerpo</em> del bucle está <em>sangrado</em>: la sangría es la forma que usa
Python para agrupar declaraciones.  El intérprete interactivo de Python
(¡aún!) no provee una facilidad inteligente para editar líneas, así que
debés teclear un tab o espacio(s) para cada línea sangrada.  En la práctica
vas a preparar entradas más complicadas para Python con un editor de
texto; la mayoría de los editores de texto tienen la facilidad de
agregar la sangría automáticamente.  Al ingresar una declaración compuesta en
forma interactiva, debés finalizar con una línea en blanco para indicar que
está completa (ya que el analizador no puede adivinar cuando tecleaste la
última línea).  Notá que cada línea de un bloque básico debe estar sangrada
de la misma forma.</p>
</li>
<li><p class="first">La declaración <tt class="xref docutils literal"><span class="pre">print</span></tt> escribe el valor de la o las expresiones que
se le pasan.  Difiere de simplemente escribir la expresión que se quiere
mostrar (como hicimos antes en los ejemplos de la calculadora) en la forma
en que maneja múltiples expresiones y cadenas.  Las cadenas de texto son
impresas sin comillas, y un espacio en blanco es insertado entre los
elementos, así podés formatear cosas de una forma agradable:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">i</span> <span class="o">=</span> <span class="mi">256</span><span class="o">*</span><span class="mi">256</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">print</span> <span class="s">&#39;El valor de i es&#39;</span><span class="p">,</span> <span class="n">i</span>
<span class="go">El valor de i es 65536</span>
</pre></div>
</div>
<p>Una coma final evita el salto de línea al final de la salida:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">while</span> <span class="n">b</span> <span class="o">&lt;</span> <span class="mi">1000</span><span class="p">:</span>
<span class="gp">... </span>    <span class="k">print</span> <span class="n">b</span><span class="p">,</span>
<span class="gp">... </span>    <span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="n">b</span><span class="p">,</span> <span class="n">a</span><span class="o">+</span><span class="n">b</span>
<span class="gp">...</span>
<span class="go">1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987</span>
</pre></div>
</div>
<p>Notá que el intérprete inserta un salto de línea antes de imprimir el
próximo prompt si la última línea no estaba completa.</p>
</li>
</ul>
</div>
</div>


          </div>
        </div>
      </div>
      <div class="sphinxsidebar">
        <div class="sphinxsidebarwrapper">
            <h3><a href="contenido.html">Contenidos</a></h3>
            <ul>
<li><a class="reference external" href="#">4. Una introducción informal a Python</a><ul>
<li><a class="reference external" href="#usar-python-como-una-calculadora">4.1. Usar Python como una calculadora</a><ul>
<li><a class="reference external" href="#numeros">4.1.1. Números</a></li>
<li><a class="reference external" href="#cadenas-de-caracteres">4.1.2. Cadenas de caracteres</a></li>
<li><a class="reference external" href="#cadenas-de-texto-unicode">4.1.3. Cadenas de texto Unicode</a></li>
<li><a class="reference external" href="#listas">4.1.4. Listas</a></li>
</ul>
</li>
<li><a class="reference external" href="#primeros-pasos-hacia-la-programacion">4.2. Primeros pasos hacia la programación</a></li>
</ul>
</li>
</ul>

            <h4>Tema anterior</h4>
            <p class="topless"><a href="interpreter.html"
                                  title="Capítulo anterior">3. Usando el intérprete de Python</a></p>
            <h4>Próximo tema</h4>
            <p class="topless"><a href="controlflow.html"
                                  title="Próximo capítulo">5. Más herramientas para control de flujo</a></p>
            <h3>Esta página</h3>
            <ul class="this-page-menu">
              <li><a href="_sources/introduction.txt"
                     rel="nofollow">Enseñar el código</a></li>
            </ul>
          <div id="searchbox" style="display: none">
            <h3>Búsqueda rápida</h3>
              <form class="search" action="search.html" method="get">
                <input type="text" name="q" size="18" />
                <input type="submit" value="Ir a" />
                <input type="hidden" name="check_keywords" value="yes" />
                <input type="hidden" name="area" value="default" />
              </form>
              <p class="searchtip" style="font-size: 90%">
              Ingrese una palabra para buscar o un nombre de módulo, clase o función
              </p>
          </div>
          <h4><a href="/"> Volver a CdPedia </a></h4>
          <script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related">
      <h3>Navegación</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="Índice General"
             >índice</a></li>
        <li class="right" >
          <a href="controlflow.html" title="5. Más herramientas para control de flujo"
             >siguiente</a> |</li>
        <li class="right" >
          <a href="interpreter.html" title="3. Usando el intérprete de Python"
             >anterior</a> |</li>
        <li><a href="contenido.html">Tutorial de Python v2.6.2 documentation</a> &raquo;</li> 
      </ul>
    </div>
    <div class="footer">
      &copy; Copyright 2009, Python Software Foundation.
      Creado con <a href="http://sphinx.pocoo.org/">Sphinx</a> 0.6.5.
    </div>
  </body>
</html>
